home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / nio / DirectByteBuffer.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  9.6 KB  |  552 lines
  1. package java.nio;
  2.  
  3. import sun.misc.Cleaner;
  4. import sun.misc.Unsafe;
  5. import sun.nio.ch.DirectBuffer;
  6.  
  7. class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer {
  8.    protected static final Unsafe unsafe = Bits.unsafe();
  9.    protected static final boolean unaligned = Bits.unaligned();
  10.    protected Object viewedBuffer = null;
  11.    private final Cleaner cleaner;
  12.  
  13.    public Object viewedBuffer() {
  14.       return this.viewedBuffer;
  15.    }
  16.  
  17.    public Cleaner cleaner() {
  18.       return this.cleaner;
  19.    }
  20.  
  21.    DirectByteBuffer(int var1) {
  22.       super(-1, 0, var1, var1, false);
  23.       Bits.reserveMemory((long)var1);
  24.       int var2 = Bits.pageSize();
  25.       long var3 = 0L;
  26.  
  27.       try {
  28.          var3 = unsafe.allocateMemory((long)(var1 + var2));
  29.       } catch (OutOfMemoryError var6) {
  30.          Bits.unreserveMemory((long)var1);
  31.          throw var6;
  32.       }
  33.  
  34.       unsafe.setMemory(var3, (long)(var1 + var2), (byte)0);
  35.       if (var3 % (long)var2 != 0L) {
  36.          this.address = var3 + (long)var2 - (var3 & (long)(var2 - 1));
  37.       } else {
  38.          this.address = var3;
  39.       }
  40.  
  41.       this.cleaner = Cleaner.create(this, new Deallocator(var3, var1, (1)null));
  42.    }
  43.  
  44.    private DirectByteBuffer(long var1, int var3) {
  45.       super(-1, 0, var3, var3, false);
  46.       this.address = var1;
  47.       this.cleaner = null;
  48.    }
  49.  
  50.    protected DirectByteBuffer(int var1, long var2, Runnable var4) {
  51.       super(-1, 0, var1, var1, true);
  52.       this.address = var2;
  53.       this.viewedBuffer = null;
  54.       this.cleaner = Cleaner.create(this, var4);
  55.    }
  56.  
  57.    DirectByteBuffer(DirectBuffer var1, int var2, int var3, int var4, int var5, int var6) {
  58.       super(var2, var3, var4, var5);
  59.       this.address = var1.address() + (long)var6;
  60.       this.viewedBuffer = var1;
  61.       this.cleaner = null;
  62.    }
  63.  
  64.    public ByteBuffer slice() {
  65.       int var1 = this.position();
  66.       int var2 = this.limit();
  67.  
  68.       assert var1 <= var2;
  69.  
  70.       int var3 = var1 <= var2 ? var2 - var1 : 0;
  71.       int var4 = var1 << 0;
  72.  
  73.       assert var4 >= 0;
  74.  
  75.       return new DirectByteBuffer(this, -1, 0, var3, var3, var4);
  76.    }
  77.  
  78.    public ByteBuffer duplicate() {
  79.       return new DirectByteBuffer(this, this.markValue(), this.position(), this.limit(), this.capacity(), 0);
  80.    }
  81.  
  82.    public ByteBuffer asReadOnlyBuffer() {
  83.       return new DirectByteBufferR(this, this.markValue(), this.position(), this.limit(), this.capacity(), 0);
  84.    }
  85.  
  86.    public long address() {
  87.       return this.address;
  88.    }
  89.  
  90.    // $FF: renamed from: ix (int) long
  91.    private long method_0(int var1) {
  92.       return this.address + (long)(var1 << 0);
  93.    }
  94.  
  95.    public byte get() {
  96.       return unsafe.getByte(this.method_0(this.nextGetIndex()));
  97.    }
  98.  
  99.    public byte get(int var1) {
  100.       return unsafe.getByte(this.method_0(this.checkIndex(var1)));
  101.    }
  102.  
  103.    public ByteBuffer get(byte[] var1, int var2, int var3) {
  104.       if (var3 << 0 > 6) {
  105.          checkBounds(var2, var3, var1.length);
  106.          int var4 = this.position();
  107.          int var5 = this.limit();
  108.  
  109.          assert var4 <= var5;
  110.  
  111.          int var6 = var4 <= var5 ? var5 - var4 : 0;
  112.          if (var3 > var6) {
  113.             throw new BufferUnderflowException();
  114.          }
  115.  
  116.          if (this.order() != ByteOrder.nativeOrder()) {
  117.             Bits.copyToByteArray(this.method_0(var4), var1, (long)(var2 << 0), (long)(var3 << 0));
  118.          } else {
  119.             Bits.copyToByteArray(this.method_0(var4), var1, (long)(var2 << 0), (long)(var3 << 0));
  120.          }
  121.  
  122.          this.position(var4 + var3);
  123.       } else {
  124.          super.get(var1, var2, var3);
  125.       }
  126.  
  127.       return this;
  128.    }
  129.  
  130.    public ByteBuffer put(byte var1) {
  131.       unsafe.putByte(this.method_0(this.nextPutIndex()), var1);
  132.       return this;
  133.    }
  134.  
  135.    public ByteBuffer put(int var1, byte var2) {
  136.       unsafe.putByte(this.method_0(this.checkIndex(var1)), var2);
  137.       return this;
  138.    }
  139.  
  140.    public ByteBuffer put(ByteBuffer var1) {
  141.       if (var1 instanceof DirectByteBuffer) {
  142.          if (var1 == this) {
  143.             throw new IllegalArgumentException();
  144.          }
  145.  
  146.          DirectByteBuffer var2 = (DirectByteBuffer)var1;
  147.          int var3 = var2.position();
  148.          int var4 = var2.limit();
  149.  
  150.          assert var3 <= var4;
  151.  
  152.          int var5 = var3 <= var4 ? var4 - var3 : 0;
  153.          int var6 = this.position();
  154.          int var7 = this.limit();
  155.  
  156.          assert var6 <= var7;
  157.  
  158.          int var8 = var6 <= var7 ? var7 - var6 : 0;
  159.          if (var5 > var8) {
  160.             throw new BufferOverflowException();
  161.          }
  162.  
  163.          unsafe.copyMemory(var2.method_0(var3), this.method_0(var6), (long)(var5 << 0));
  164.          var2.position(var3 + var5);
  165.          this.position(var6 + var5);
  166.       } else if (var1.hb != null) {
  167.          int var9 = var1.position();
  168.          int var10 = var1.limit();
  169.  
  170.          assert var9 <= var10;
  171.  
  172.          int var11 = var9 <= var10 ? var10 - var9 : 0;
  173.          this.put(var1.hb, var1.offset + var9, var11);
  174.          var1.position(var9 + var11);
  175.       } else {
  176.          super.put(var1);
  177.       }
  178.  
  179.       return this;
  180.    }
  181.  
  182.    public ByteBuffer put(byte[] var1, int var2, int var3) {
  183.       if (var3 << 0 > 6) {
  184.          checkBounds(var2, var3, var1.length);
  185.          int var4 = this.position();
  186.          int var5 = this.limit();
  187.  
  188.          assert var4 <= var5;
  189.  
  190.          int var6 = var4 <= var5 ? var5 - var4 : 0;
  191.          if (var3 > var6) {
  192.             throw new BufferOverflowException();
  193.          }
  194.  
  195.          if (this.order() != ByteOrder.nativeOrder()) {
  196.             Bits.copyFromByteArray(var1, (long)(var2 << 0), this.method_0(var4), (long)(var3 << 0));
  197.          } else {
  198.             Bits.copyFromByteArray(var1, (long)(var2 << 0), this.method_0(var4), (long)(var3 << 0));
  199.          }
  200.  
  201.          this.position(var4 + var3);
  202.       } else {
  203.          super.put(var1, var2, var3);
  204.       }
  205.  
  206.       return this;
  207.    }
  208.  
  209.    public ByteBuffer compact() {
  210.       int var1 = this.position();
  211.       int var2 = this.limit();
  212.  
  213.       assert var1 <= var2;
  214.  
  215.       int var3 = var1 <= var2 ? var2 - var1 : 0;
  216.       unsafe.copyMemory(this.method_0(var1), this.method_0(0), (long)(var3 << 0));
  217.       this.position(var3);
  218.       this.limit(this.capacity());
  219.       return this;
  220.    }
  221.  
  222.    public boolean isDirect() {
  223.       return true;
  224.    }
  225.  
  226.    public boolean isReadOnly() {
  227.       return false;
  228.    }
  229.  
  230.    byte _get(int var1) {
  231.       return unsafe.getByte(this.address + (long)var1);
  232.    }
  233.  
  234.    void _put(int var1, byte var2) {
  235.       unsafe.putByte(this.address + (long)var1, var2);
  236.    }
  237.  
  238.    private char getChar(long var1) {
  239.       if (unaligned) {
  240.          char var3 = unsafe.getChar(var1);
  241.          return this.nativeByteOrder ? var3 : Bits.swap(var3);
  242.       } else {
  243.          return Bits.getChar(var1, this.bigEndian);
  244.       }
  245.    }
  246.  
  247.    public char getChar() {
  248.       return this.getChar(this.method_0(this.nextGetIndex(2)));
  249.    }
  250.  
  251.    public char getChar(int var1) {
  252.       return this.getChar(this.method_0(this.checkIndex(var1, 2)));
  253.    }
  254.  
  255.    private ByteBuffer putChar(long var1, char var3) {
  256.       if (unaligned) {
  257.          unsafe.putChar(var1, this.nativeByteOrder ? var3 : Bits.swap(var3));
  258.       } else {
  259.          Bits.putChar(var1, var3, this.bigEndian);
  260.       }
  261.  
  262.       return this;
  263.    }
  264.  
  265.    public ByteBuffer putChar(char var1) {
  266.       this.putChar(this.method_0(this.nextPutIndex(2)), var1);
  267.       return this;
  268.    }
  269.  
  270.    public ByteBuffer putChar(int var1, char var2) {
  271.       this.putChar(this.method_0(this.checkIndex(var1, 2)), var2);
  272.       return this;
  273.    }
  274.  
  275.    public CharBuffer asCharBuffer() {
  276.       int var1 = this.position();
  277.       int var2 = this.limit();
  278.  
  279.       assert var1 <= var2;
  280.  
  281.       int var3 = var1 <= var2 ? var2 - var1 : 0;
  282.       int var4 = var3 >> 1;
  283.       if (!unaligned && (this.address + (long)var1) % 2L != 0L) {
  284.          return (CharBuffer)(this.bigEndian ? new ByteBufferAsCharBufferB(this, -1, 0, var4, var4, var1) : new ByteBufferAsCharBufferL(this, -1, 0, var4, var4, var1));
  285.       } else {
  286.          return (CharBuffer)(this.nativeByteOrder ? new DirectCharBufferU(this, -1, 0, var4, var4, var1) : new DirectCharBufferS(this, -1, 0, var4, var4, var1));
  287.       }
  288.    }
  289.  
  290.    private short getShort(long var1) {
  291.       if (unaligned) {
  292.          short var3 = unsafe.getShort(var1);
  293.          return this.nativeByteOrder ? var3 : Bits.swap(var3);
  294.       } else {
  295.          return Bits.getShort(var1, this.bigEndian);
  296.       }
  297.    }
  298.  
  299.    public short getShort() {
  300.       return this.getShort(this.method_0(this.nextGetIndex(2)));
  301.    }
  302.  
  303.    public short getShort(int var1) {
  304.       return this.getShort(this.method_0(this.checkIndex(var1, 2)));
  305.    }
  306.  
  307.    private ByteBuffer putShort(long var1, short var3) {
  308.       if (unaligned) {
  309.          unsafe.putShort(var1, this.nativeByteOrder ? var3 : Bits.swap(var3));
  310.       } else {
  311.          Bits.putShort(var1, var3, this.bigEndian);
  312.       }
  313.  
  314.       return this;
  315.    }
  316.  
  317.    public ByteBuffer putShort(short var1) {
  318.       this.putShort(this.method_0(this.nextPutIndex(2)), var1);
  319.       return this;
  320.    }
  321.  
  322.    public ByteBuffer putShort(int var1, short var2) {
  323.       this.putShort(this.method_0(this.checkIndex(var1, 2)), var2);
  324.       return this;
  325.    }
  326.  
  327.    public ShortBuffer asShortBuffer() {
  328.       int var1 = this.position();
  329.       int var2 = this.limit();
  330.  
  331.       assert var1 <= var2;
  332.  
  333.       int var3 = var1 <= var2 ? var2 - var1 : 0;
  334.       int var4 = var3 >> 1;
  335.       if (!unaligned && (this.address + (long)var1) % 2L != 0L) {
  336.          return (ShortBuffer)(this.bigEndian ? new ByteBufferAsShortBufferB(this, -1, 0, var4, var4, var1) : new ByteBufferAsShortBufferL(this, -1, 0, var4, var4, var1));
  337.       } else {
  338.          return (ShortBuffer)(this.nativeByteOrder ? new DirectShortBufferU(this, -1, 0, var4, var4, var1) : new DirectShortBufferS(this, -1, 0, var4, var4, var1));
  339.       }
  340.    }
  341.  
  342.    private int getInt(long var1) {
  343.       if (unaligned) {
  344.          int var3 = unsafe.getInt(var1);
  345.          return this.nativeByteOrder ? var3 : Bits.swap(var3);
  346.       } else {
  347.          return Bits.getInt(var1, this.bigEndian);
  348.       }
  349.    }
  350.  
  351.    public int getInt() {
  352.       return this.getInt(this.method_0(this.nextGetIndex(4)));
  353.    }
  354.  
  355.    public int getInt(int var1) {
  356.       return this.getInt(this.method_0(this.checkIndex(var1, 4)));
  357.    }
  358.  
  359.    private ByteBuffer putInt(long var1, int var3) {
  360.       if (unaligned) {
  361.          unsafe.putInt(var1, this.nativeByteOrder ? var3 : Bits.swap(var3));
  362.       } else {
  363.          Bits.putInt(var1, var3, this.bigEndian);
  364.       }
  365.  
  366.       return this;
  367.    }
  368.  
  369.    public ByteBuffer putInt(int var1) {
  370.       this.putInt(this.method_0(this.nextPutIndex(4)), var1);
  371.       return this;
  372.    }
  373.  
  374.    public ByteBuffer putInt(int var1, int var2) {
  375.       this.putInt(this.method_0(this.checkIndex(var1, 4)), var2);
  376.       return this;
  377.    }
  378.  
  379.    public IntBuffer asIntBuffer() {
  380.       int var1 = this.position();
  381.       int var2 = this.limit();
  382.  
  383.       assert var1 <= var2;
  384.  
  385.       int var3 = var1 <= var2 ? var2 - var1 : 0;
  386.       int var4 = var3 >> 2;
  387.       if (!unaligned && (this.address + (long)var1) % 4L != 0L) {
  388.          return (IntBuffer)(this.bigEndian ? new ByteBufferAsIntBufferB(this, -1, 0, var4, var4, var1) : new ByteBufferAsIntBufferL(this, -1, 0, var4, var4, var1));
  389.       } else {
  390.          return (IntBuffer)(this.nativeByteOrder ? new DirectIntBufferU(this, -1, 0, var4, var4, var1) : new DirectIntBufferS(this, -1, 0, var4, var4, var1));
  391.       }
  392.    }
  393.  
  394.    private long getLong(long var1) {
  395.       if (unaligned) {
  396.          long var3 = unsafe.getLong(var1);
  397.          return this.nativeByteOrder ? var3 : Bits.swap(var3);
  398.       } else {
  399.          return Bits.getLong(var1, this.bigEndian);
  400.       }
  401.    }
  402.  
  403.    public long getLong() {
  404.       return this.getLong(this.method_0(this.nextGetIndex(8)));
  405.    }
  406.  
  407.    public long getLong(int var1) {
  408.       return this.getLong(this.method_0(this.checkIndex(var1, 8)));
  409.    }
  410.  
  411.    private ByteBuffer putLong(long var1, long var3) {
  412.       if (unaligned) {
  413.          unsafe.putLong(var1, this.nativeByteOrder ? var3 : Bits.swap(var3));
  414.       } else {
  415.          Bits.putLong(var1, var3, this.bigEndian);
  416.       }
  417.  
  418.       return this;
  419.    }
  420.  
  421.    public ByteBuffer putLong(long var1) {
  422.       this.putLong(this.method_0(this.nextPutIndex(8)), var1);
  423.       return this;
  424.    }
  425.  
  426.    public ByteBuffer putLong(int var1, long var2) {
  427.       this.putLong(this.method_0(this.checkIndex(var1, 8)), var2);
  428.       return this;
  429.    }
  430.  
  431.    public LongBuffer asLongBuffer() {
  432.       int var1 = this.position();
  433.       int var2 = this.limit();
  434.  
  435.       assert var1 <= var2;
  436.  
  437.       int var3 = var1 <= var2 ? var2 - var1 : 0;
  438.       int var4 = var3 >> 3;
  439.       if (!unaligned && (this.address + (long)var1) % 8L != 0L) {
  440.          return (LongBuffer)(this.bigEndian ? new ByteBufferAsLongBufferB(this, -1, 0, var4, var4, var1) : new ByteBufferAsLongBufferL(this, -1, 0, var4, var4, var1));
  441.       } else {
  442.          return (LongBuffer)(this.nativeByteOrder ? new DirectLongBufferU(this, -1, 0, var4, var4, var1) : new DirectLongBufferS(this, -1, 0, var4, var4, var1));
  443.       }
  444.    }
  445.  
  446.    private float getFloat(long var1) {
  447.       if (unaligned) {
  448.          int var3 = unsafe.getInt(var1);
  449.          return Float.intBitsToFloat(this.nativeByteOrder ? var3 : Bits.swap(var3));
  450.       } else {
  451.          return Bits.getFloat(var1, this.bigEndian);
  452.       }
  453.    }
  454.  
  455.    public float getFloat() {
  456.       return this.getFloat(this.method_0(this.nextGetIndex(4)));
  457.    }
  458.  
  459.    public float getFloat(int var1) {
  460.       return this.getFloat(this.method_0(this.checkIndex(var1, 4)));
  461.    }
  462.  
  463.    private ByteBuffer putFloat(long var1, float var3) {
  464.       if (unaligned) {
  465.          int var4 = Float.floatToRawIntBits(var3);
  466.          unsafe.putInt(var1, this.nativeByteOrder ? var4 : Bits.swap(var4));
  467.       } else {
  468.          Bits.putFloat(var1, var3, this.bigEndian);
  469.       }
  470.  
  471.       return this;
  472.    }
  473.  
  474.    public ByteBuffer putFloat(float var1) {
  475.       this.putFloat(this.method_0(this.nextPutIndex(4)), var1);
  476.       return this;
  477.    }
  478.  
  479.    public ByteBuffer putFloat(int var1, float var2) {
  480.       this.putFloat(this.method_0(this.checkIndex(var1, 4)), var2);
  481.       return this;
  482.    }
  483.  
  484.    public FloatBuffer asFloatBuffer() {
  485.       int var1 = this.position();
  486.       int var2 = this.limit();
  487.  
  488.       assert var1 <= var2;
  489.  
  490.       int var3 = var1 <= var2 ? var2 - var1 : 0;
  491.       int var4 = var3 >> 2;
  492.       if (!unaligned && (this.address + (long)var1) % 4L != 0L) {
  493.          return (FloatBuffer)(this.bigEndian ? new ByteBufferAsFloatBufferB(this, -1, 0, var4, var4, var1) : new ByteBufferAsFloatBufferL(this, -1, 0, var4, var4, var1));
  494.       } else {
  495.          return (FloatBuffer)(this.nativeByteOrder ? new DirectFloatBufferU(this, -1, 0, var4, var4, var1) : new DirectFloatBufferS(this, -1, 0, var4, var4, var1));
  496.       }
  497.    }
  498.  
  499.    private double getDouble(long var1) {
  500.       if (unaligned) {
  501.          long var3 = unsafe.getLong(var1);
  502.          return Double.longBitsToDouble(this.nativeByteOrder ? var3 : Bits.swap(var3));
  503.       } else {
  504.          return Bits.getDouble(var1, this.bigEndian);
  505.       }
  506.    }
  507.  
  508.    public double getDouble() {
  509.       return this.getDouble(this.method_0(this.nextGetIndex(8)));
  510.    }
  511.  
  512.    public double getDouble(int var1) {
  513.       return this.getDouble(this.method_0(this.checkIndex(var1, 8)));
  514.    }
  515.  
  516.    private ByteBuffer putDouble(long var1, double var3) {
  517.       if (unaligned) {
  518.          long var5 = Double.doubleToRawLongBits(var3);
  519.          unsafe.putLong(var1, this.nativeByteOrder ? var5 : Bits.swap(var5));
  520.       } else {
  521.          Bits.putDouble(var1, var3, this.bigEndian);
  522.       }
  523.  
  524.       return this;
  525.    }
  526.  
  527.    public ByteBuffer putDouble(double var1) {
  528.       this.putDouble(this.method_0(this.nextPutIndex(8)), var1);
  529.       return this;
  530.    }
  531.  
  532.    public ByteBuffer putDouble(int var1, double var2) {
  533.       this.putDouble(this.method_0(this.checkIndex(var1, 8)), var2);
  534.       return this;
  535.    }
  536.  
  537.    public DoubleBuffer asDoubleBuffer() {
  538.       int var1 = this.position();
  539.       int var2 = this.limit();
  540.  
  541.       assert var1 <= var2;
  542.  
  543.       int var3 = var1 <= var2 ? var2 - var1 : 0;
  544.       int var4 = var3 >> 3;
  545.       if (!unaligned && (this.address + (long)var1) % 8L != 0L) {
  546.          return (DoubleBuffer)(this.bigEndian ? new ByteBufferAsDoubleBufferB(this, -1, 0, var4, var4, var1) : new ByteBufferAsDoubleBufferL(this, -1, 0, var4, var4, var1));
  547.       } else {
  548.          return (DoubleBuffer)(this.nativeByteOrder ? new DirectDoubleBufferU(this, -1, 0, var4, var4, var1) : new DirectDoubleBufferS(this, -1, 0, var4, var4, var1));
  549.       }
  550.    }
  551. }
  552.